package com.voxel.sense.infomsg.view;

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.AttributeSet;
import android.view.View;

import com.example.com.common.utils.L;
import com.example.com.common.utils.ToastUtil;
import com.voxel.sense.infomsg.R;
import com.voxel.sense.infomsg.utils.JZMediaIjkplayer;

import cn.jzvd.JZUtils;
import cn.jzvd.JzvdStd;
import cyy.example.com.facotry.Factory;

/**
 * Created by ChenYiYao on 2017/11/29.
 * 自定义的播放器view
 */

public class MyJZVideoPlayerPlay extends JzvdStd {
    boolean mEnablePlayer = true;//是否能播放
    //    boolean mIsNeedDelay = true;//第一次加载视频，需要启动直播，需要延迟加载
    private String mUnavailable = "暂无有效的播放源";
    private Handler mHandler;
    private Runnable mRunnable;

    //发生错误，继续重播的消息码
    private static final int ERROR_MES_TRY_AGAIN_PALY = 1010;
    //发生错误后，再次尝试自动播放最大次数
    private static final int TRY_AUTO_PLAY_MAX_COUNT = 12;
    //播放前的延迟时间
    private static final int DELAYED_TIME = 5000;
    //标记是否需要延迟加载视频，若是播放成功过的视频，再证明已拉流成功，无需延迟。否则需要
    private boolean is_delay_play = true;
    private int currentAutoPlayTime = 0;


    public MyJZVideoPlayerPlay(Context context) {
        super(context, null);
    }

    public MyJZVideoPlayerPlay(Context context, AttributeSet attrs) {
        super(context, attrs);
        initHandler();
    }

    private void initHandler() {
        mHandler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (msg.what == ERROR_MES_TRY_AGAIN_PALY) {
                    startVideo();
                }
            }
        };
    }


    @Override
    public void onClick(final View v) {
        if (!mEnablePlayer) {
            ToastUtil.showToastLong(Factory.app(), mUnavailable);
            return;
        }

        //点击播放时，先判断直播是否第一次开启需要延迟加载。
        if ((v.getId() == R.id.thumb || v.getId() == R.id.start) && state == STATE_NORMAL && is_delay_play) {
            if (!jzDataSource.getCurrentUrl().toString().startsWith("file") &&
                    !jzDataSource.getCurrentUrl().toString().startsWith("/") &&
                    !JZUtils.isWifiConnected(getContext()) && !WIFI_TIP_DIALOG_SHOWED) {
                //若不是使用wifi这里进入这里
                showWifiDialog();
                return;
            }
            //显示加载按钮
            loadingProgressBar.setVisibility(VISIBLE);
            //隐藏播放按钮
            startButton.setVisibility(GONE);
//            mRetryLayout.setVisibility(INVISIBLE);
            if (mHandler == null) {
                initHandler();
            }
            if (mRunnable != null) {
                mHandler.removeCallbacks(mRunnable);
            } else {
                //开始的事件应该在播放之后，此处特殊
                removeHandlerMsg();
                mRunnable = new Runnable() {
                    @Override
                    public void run() {
                        MyJZVideoPlayerPlay.super.onClick(v);
                    }
                };
            }

            mHandler.postDelayed(mRunnable, DELAYED_TIME);
            return;
        } else if (state == STATE_ERROR) {
            //且在饺子播放器7.0.3版本中，发生错误之后，再次点击重播按钮只是进行了UI的变化，没有重新连接播放，只是单纯的显示加载图标。
            removeHandlerMsg();
            mHandler.sendEmptyMessageDelayed(ERROR_MES_TRY_AGAIN_PALY, DELAYED_TIME);
        }
        super.onClick(v);
    }


    public void removeHandler() {
        if (loadingProgressBar.getVisibility() == View.VISIBLE) {
            loadingProgressBar.setVisibility(GONE);
            startButton.setVisibility(VISIBLE);
        }
        removeHandlerMsg();
        mHandler = null;
        mRunnable = null;
    }

    /**
     * 移除消息
     */
    private void removeHandlerMsg() {
        if (mHandler != null) {
            if (mRunnable != null) {
                mHandler.removeCallbacks(mRunnable);
            }
            mHandler.removeMessages(ERROR_MES_TRY_AGAIN_PALY);
        }
    }

    public boolean isEnablePlayer() {
        return mEnablePlayer;
    }

    public void setEnablePlayer(boolean enablePlayer) {
        mEnablePlayer = enablePlayer;
    }

    public String getUnavailable() {
        return mUnavailable;
    }

    public void setUnavailable(String unavailable) {
        mUnavailable = unavailable;
    }

    @Override
    public void onStatePlaying() {
        super.onStatePlaying();
        is_delay_play = false;
    }

    @Override
    public void onError(int what, int extra) {
        super.onError(what, extra);
        /**
         * 根据测试，连接阿里云失败后，使用Ijkplayer引擎第一个参数返回的是-10000，其它播放器引擎暂时未测试。
         * 且在饺子播放器7.0.3版本中，发生错误之后，再次点击重播按钮只是进行了UI的变化，没有重新连接播放，只是单纯的显示加载图标。
         * 这里只要连接发生错误，则继续重连播放
         */
//        if ((mediaInterface instanceof JZMediaIjkplayer) && what == -10000) {
//
//        }
        if (mHandler != null && currentAutoPlayTime <= TRY_AUTO_PLAY_MAX_COUNT) {
            mHandler.removeMessages(ERROR_MES_TRY_AGAIN_PALY);
            currentAutoPlayTime++;
            //改变ui状态，进入准备状态
            changeUiToPreparing();
            mHandler.sendEmptyMessageDelayed(ERROR_MES_TRY_AGAIN_PALY, DELAYED_TIME);
        }
        //视频播放失败，可能是推流服务出现问题，改变标记，延迟加载。
        is_delay_play = true;
    }

    @Override
    public void changeUiToError() {
        super.changeUiToError();
    }

    @Override
    public void onStateError() {
        super.onStateError();
    }
}
